home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Precision Software Appli…tions Silver Collection 1
/
Precision Software Applications Silver Collection Volume One (PSM) (1993).iso
/
games
/
egavga
/
snarff.exe
/
DISPIO.ASM
< prev
next >
Wrap
Assembly Source File
|
1988-01-16
|
40KB
|
1,981 lines
page 60,132
title DISPLAY I/O ROUTINES for CGA in 320x200 graphics mode
font1 equ 0
;
; for this entire module, the origin (0,0) is at the bottom-left of the screen.
;
; Everett Kaser 11-03-86
; for C 06-24-87
CGA EQU 0
EGA EQU 1
;
_text segment byte public 'code'
_text ends
_data segment word public 'data'
_data ends
const segment word public 'const'
const ends
_bss segment word public 'bss'
_bss ends
;
public _beepflg
public _timepass
public timerint
public _beep_seq
public _take_timer
public _give_timer
public _setmode
public _setcolors
public _plotxy
public _bplotxy
public _line
public _horline
public _verline
public _clrscreen
public _setrand
public _rand
public _beepon
public _beepoff
public _flabel
public _iskey
public _key
public _movebytes
public _newbplotxy
;
public _machine
;
dgroup group const, _bss, _data
assume cs:_text, ds:dgroup, ss:dgroup, es:dgroup
;
_data segment word public 'data'
;
_beepflg dw 1
;
beeptime dw 0
beepptr dw 0
;
_timepass dw 0
;
_machine dw ?
;
seed dw 4,0
;
color db ?
rule db ?
backclr db ?
string dw ?
rowcnt db ?
colcnt db ?
x1 dw ?
y1 dw ?
x2 dw ?
y2 dw ?
stepx dw ?
stepy dw ?
difx dw ?
dify dw ?
halfdifx dw ?
halfdify dw ?
;
vidseg dw ?
;
widtht dw ?
height dw ?
wcount dw ?
hcount dw ?
pcount db ?
;
maskbyte db ?
masks db 256 dup (0)
;
if font1
chartab db 00h,00h,00h,00h,00h,00h,00h,00h ; 0
db 0Eh,10h,0Ch,02h,1Ch,05h,07h,05h
db 0Eh,10h,0Ch,02h,1Ch,05h,02h,05h
db 1Ch,10h,1Ch,10h,1Ch,05h,02h,05h
db 1Ch,10h,1Ch,10h,1Ch,07h,02h,02h
db 1Ch,10h,1Ch,10h,1Ch,0Ah,0Ah,07h
db 0Ch,12h,1Eh,12h,04h,05h,06h,05h
db 1Ch,12h,1Ch,12h,1Ch,04h,04h,07h
db 1Ch,12h,1Ch,12h,1Fh,04h,02h,0Ch
db 14h,14h,1Ch,14h,14h,07h,02h,02h
db 10h,10h,10h,1Ch,07h,04h,06h,04h ; 10
db 11h,0Ah,04h,00h,07h,02h,02h,02h
db 1Eh,10h,1Ch,10h,17h,04h,06h,04h
db 0Ch,12h,10h,10h,0Eh,09h,0Eh,09h
db 0Eh,10h,0Ch,02h,1Eh,09h,09h,06h
db 0Eh,10h,0Ch,02h,1Ch,07h,02h,07h
db 1Ch,12h,12h,1Ch,00h,04h,04h,07h
db 1Ch,12h,12h,1Ch,01h,01h,01h,01h
db 1Ch,12h,12h,1Ch,06h,01h,02h,07h
db 1Ch,12h,12h,1Fh,01h,03h,01h,07h
db 1Ch,12h,12h,1Ch,05h,05h,07h,01h ; 20
db 12h,1Ah,16h,12h,04h,05h,06h,05h
db 0Eh,10h,0Ch,02h,1Dh,0Dh,0Bh,09h
db 1Ch,10h,18h,16h,1Dh,06h,05h,06h
db 0Ch,12h,10h,0Ch,09h,0Dh,0Bh,09h
db 1Ch,10h,1Ch,10h,1Dh,1Bh,15h,11h
db 07h,08h,04h,1Eh,05h,06h,05h,06h
db 1Ch,10h,1Ch,10h,1Fh,04h,04h,03h
db 1Eh,10h,1Ch,10h,13h,04h,02h,0Ch
db 0Eh,10h,16h,12h,0Fh,04h,02h,0Ch
db 1Ch,12h,1Ch,12h,13h,04h,02h,0Ch ; 30
db 12h,12h,12h,0Ch,03h,04h,02h,0Ch
db 00h,00h,00h,00h,00h,00h,00h,00h
db 06h,06h,06h,06h,06h,00h,06h,00h
db 1Bh,1Bh,09h,12h,00h,00h,00h,00h
db 00h,0Ah,1Fh,0Ah,1Fh,0Ah,00h,00h
db 04h,0Fh,14h,0Eh,05h,1Eh,04h,00h
db 18h,19h,02h,04h,08h,13h,03h,00h
db 0Ch,1Ah,1Ah,0Dh,1Ah,1Ah,0Dh,00h
db 06h,06h,02h,04h,00h,00h,00h,00h
db 06h,0Ch,18h,18h,18h,0Ch,06h,00h ; 40
db 0Ch,06h,03h,03h,03h,06h,0Ch,00h
db 00h,0Ah,04h,1Fh,04h,0Ah,00h,00h
db 00h,04h,04h,1Fh,04h,04h,00h,00h
db 00h,00h,00h,00h,06h,06h,02h,04h
db 00h,00h,00h,1Fh,00h,00h,00h,00h
db 00h,00h,00h,00h,00h,06h,06h,00h
db 00h,01h,03h,06h,0Ch,18h,10h,00h
db 0Eh,19h,19h,1Bh,1Dh,19h,0Eh,00h
db 06h,0Eh,06h,06h,06h,06h,0Fh,00h
db 0Eh,13h,03h,06h,0Ch,18h,1Fh,00h ; 50
db 0Eh,13h,03h,0Eh,03h,13h,0Eh,00h
db 16h,16h,16h,16h,1Fh,06h,06h,00h
db 1Fh,18h,1Eh,03h,03h,13h,0Eh,00h
db 0Eh,19h,18h,1Eh,19h,19h,0Eh,00h
db 1Fh,03h,06h,0Ch,0Ch,0Ch,0Ch,00h
db 0Eh,19h,19h,0Eh,19h,19h,0Eh,00h
db 0Eh,13h,13h,0Fh,03h,13h,0Eh,00h
db 00h,06h,06h,00h,06h,06h,00h,00h
db 00h,06h,06h,00h,06h,06h,02h,04h
db 03h,06h,0Ch,18h,0Ch,06h,03h,00h ; 60
db 00h,00h,1Fh,00h,1Fh,00h,00h,00h
db 18h,0Ch,06h,03h,06h,0Ch,18h,00h
db 0Eh,13h,03h,06h,04h,00h,04h,00h
db 0Eh,11h,17h,15h,17h,10h,0Fh,00h
db 0Eh,19h,19h,1Fh,19h,19h,19h,00h
db 1Eh,19h,19h,1Eh,19h,19h,1Eh,00h
db 0Eh,19h,18h,18h,18h,19h,0Eh,00h
db 1Eh,19h,19h,19h,19h,19h,1Eh,00h
db 1Fh,18h,18h,1Eh,18h,18h,1Fh,00h
db 1Fh,18h,18h,1Eh,18h,18h,18h,00h ; 70
db 0Eh,19h,18h,1Bh,19h,19h,0Fh,00h
db 19h,19h,19h,1Fh,19h,19h,19h,00h
db 0Fh,06h,06h,06h,06h,06h,0Fh,00h
db 1Fh,06h,06h,06h,16h,16h,0Ch,00h
db 19h,1Ah,1Ch,18h,1Ch,1Ah,19h,00h
db 18h,18h,18h,18h,18h,18h,1Fh,00h
db 11h,1Bh,1Fh,15h,15h,11h,11h,00h
db 19h,19h,1Dh,1Fh,1Bh,19h,19h,00h
db 0Eh,19h,19h,19h,19h,19h,0Eh,00h
db 1Eh,19h,19h,1Eh,18h,18h,18h,00h ; 80
db 0Eh,19h,19h,19h,1Dh,1Ah,0Dh,00h
db 1Eh,19h,19h,1Eh,1Bh,19h,19h,00h
db 0Eh,19h,18h,0Eh,03h,13h,0Eh,00h
db 1Fh,0Ch,0Ch,0Ch,0Ch,0Ch,0Ch,00h
db 19h,19h,19h,19h,19h,19h,0Eh,00h
db 19h,19h,19h,19h,19h,0Ah,04h,00h
db 11h,11h,15h,15h,1Fh,1Bh,11h,00h
db 19h,1Bh,0Eh,04h,0Eh,1Bh,13h,00h
db 19h,19h,0Bh,0Eh,06h,06h,06h,00h
db 1Fh,03h,07h,0Eh,1Ch,18h,1Fh,00h ; 90
db 1Eh,18h,18h,18h,18h,18h,1Eh,00h
db 00h,10h,18h,0Ch,06h,03h,01h,00h
db 0Fh,03h,03h,03h,03h,03h,0Fh,00h
db 04h,0Eh,1Bh,11h,00h,00h,00h,00h
db 00h,00h,00h,00h,00h,00h,3Fh,00h
db 04h,08h,0Ch,0Ch,00h,00h,00h,00h
db 00h,00h,0Eh,03h,0Fh,13h,0Fh,00h
db 18h,18h,1Eh,19h,19h,19h,1Eh,00h
db 00h,00h,0Eh,19h,18h,18h,0Fh,00h
db 03h,03h,0Fh,13h,13h,13h,0Fh,00h ; 100
db 00h,00h,0Eh,19h,1Fh,18h,0Fh,00h
db 07h,0Ch,1Fh,0Ch,0Ch,0Ch,1Eh,00h
db 00h,00h,0Fh,13h,13h,0Fh,03h,1Eh
db 18h,18h,1Eh,19h,19h,19h,19h,00h
db 06h,00h,0Eh,06h,06h,06h,0Fh,00h
db 03h,00h,07h,03h,03h,03h,13h,0Eh
db 18h,18h,19h,1Ah,1Ch,1Ah,19h,00h
db 0Eh,06h,06h,06h,06h,06h,0Fh,00h
db 00h,00h,11h,1Bh,1Fh,15h,11h,00h
db 00h,00h,1Eh,19h,19h,19h,19h,00h ; 110
db 00h,00h,0Eh,19h,19h,19h,0Eh,00h
db 00h,00h,1Eh,19h,19h,1Eh,18h,18h
db 00h,00h,0Fh,13h,13h,0Fh,03h,03h
db 00h,00h,1Eh,19h,18h,18h,18h,00h
db 00h,00h,0Fh,18h,1Fh,03h,1Eh,00h
db 0Ch,0Ch,1Fh,0Ch,0Ch,0Dh,06h,00h
db 00h,00h,13h,13h,13h,13h,0Fh,00h
db 00h,00h,19h,19h,19h,0Ah,04h,00h
db 00h,00h,11h,15h,1Fh,1Bh,11h,00h
db 00h,00h,19h,0Eh,04h,0Eh,13h,00h ; 120
db 00h,00h,13h,13h,13h,0Fh,03h,1Eh
db 00h,00h,1Fh,06h,0Ch,18h,1Fh,00h
db 07h,0Ch,0Ch,18h,0Ch,0Ch,07h,00h
db 06h,06h,06h,06h,06h,06h,06h,00h
db 1Ch,06h,06h,03h,06h,06h,1Ch,00h
db 00h,08h,1Dh,17h,02h,00h,00h,00h
db 15h,0Ah,15h,0Ah,15h,0Ah,15h,00h
else
chartab db 4,12,28,60,28,12,4,0 ; 0
db 8,0,8,16,34,34,28,0
db 124,0,68,40,16,40,68,0
db 124,0,68,100,84,76,68,0
db 0,0,52,72,72,72,52,0
db 56,68,68,120,68,68,120,0
db 124,68,32,16,32,68,124,0
db 0,16,8,124,8,16,0,0
db 0,16,32,124,32,16,0,0
db 16,16,16,16,84,56,16,0
db 16,56,84,16,16,16,16,0 ; 10
db 64,32,16,40,68,68,68,0
db 0,0,36,36,36,56,64,0
db 0,0,0,0,0,0,0,0
db 0,4,56,80,16,16,16,0
db 0,4,56,104,40,40,40,0
db 56,68,68,124,68,68,56,0
db 60,80,80,120,80,80,124,0
db 0,0,40,84,92,80,60,0
db 16,56,68,68,124,68,68,0
db 16,0,56,72,72,72,52,0 ; 20
db 40,56,68,68,124,68,68,0
db 40,0,56,72,72,72,52,0
db 40,56,68,68,68,68,56,0
db 40,0,56,68,68,68,56,0
db 40,68,68,68,68,68,56,0
db 40,0,68,68,68,68,56,0
db 64,64,64,124,64,64,64,0
db 24,24,24,24,24,24,24,24
db 0,0,0,255,255,0,0,0
db 24,36,32,112,32,32,124,0 ; 30
db 24,24,24,255,255,24,24,24
db 0,0,0,0,0,0,0,0
db 8,8,8,8,8,0,8,0
db 40,40,40,0,0,0,0,0
db 40,40,124,40,124,40,40,0
db 16,60,80,56,20,120,16,0
db 96,100,8,16,32,76,12,0
db 32,80,80,32,84,72,52,0
db 8,8,8,0,0,0,0,0
db 16,32,64,64,64,32,16,0 ; 40
db 16,8,4,4,4,8,16,0
db 16,84,56,16,56,84,16,0
db 0,16,16,124,16,16,0,0
db 0,0,0,0,8,8,16,0
db 0,0,0,124,0,0,0,0
db 0,0,0,0,0,8,0,0
db 0,4,8,16,32,64,0,0
db 56,68,76,84,100,68,56,0
db 16,48,16,16,16,16,56,0
db 56,68,4,24,32,64,124,0 ; 50
db 124,4,8,24,4,68,56,0
db 8,24,40,72,124,8,8,0
db 124,64,120,4,4,68,56,0
db 28,32,64,120,68,68,56,0
db 124,4,8,16,32,32,32,0
db 56,68,68,56,68,68,56,0
db 56,68,68,60,4,8,112,0
db 0,0,16,0,16,0,0,0
db 0,0,16,0,16,16,32,0
db 4,8,16,32,16,8,4,0 ; 60
db 0,0,124,0,124,0,0,0
db 64,32,16,8,16,32,64,0
db 56,68,68,8,16,0,16,0
db 56,68,84,88,88,64,60,0
db 56,68,68,124,68,68,68,0 ; 65 A
db 120,68,68,120,68,68,120,0
db 56,68,64,64,64,68,56,0
db 120,68,68,68,68,68,120,0
db 124,64,64,120,64,64,124,0
db 124,64,64,120,64,64,64,0 ; 70
db 60,64,64,64,76,68,60,0
db 68,68,68,124,68,68,68,0
db 56,16,16,16,16,16,56,0
db 4,4,4,4,4,68,56,0
db 68,72,80,96,80,72,68,0
db 64,64,64,64,64,64,124,0
db 68,108,84,84,68,68,68,0
db 68,68,100,84,76,68,68,0
db 56,68,68,68,68,68,56,0
db 120,68,68,120,64,64,64,0 ; 80
db 56,68,68,68,84,72,52,0
db 120,68,68,120,80,72,68,0
db 56,68,64,56,4,68,56,0
db 124,16,16,16,16,16,16,0
db 68,68,68,68,68,68,56,0
db 68,68,68,68,40,40,16,0
db 68,68,68,84,84,108,68,0
db 68,68,40,16,40,68,68,0
db 68,68,40,16,16,16,16,0
db 124,4,8,16,32,64,124,0 ; 90
db 124,96,96,96,96,96,124,0
db 0,64,32,16,8,4,0,0
db 124,12,12,12,12,12,124,0
db 16,40,68,0,0,0,0,0
db 0,0,0,0,0,0,124,0
db 64,32,16,8,0,0,0,0
db 0,0,56,4,60,68,60,0
db 64,64,88,100,68,68,120,0
db 0,0,0,60,64,64,60,0
db 4,4,52,76,68,68,60,0 ; 100
db 0,0,56,68,124,64,56,0
db 8,16,16,56,16,16,16,0
db 0,0,60,68,60,4,24,0
db 64,64,88,100,68,68,68,0
db 0,8,0,24,8,8,28,0
db 0,4,0,4,4,36,24,0
db 32,32,36,40,48,40,36,0
db 24,8,8,8,8,8,28,0
db 0,0,104,84,84,84,84,0
db 0,0,88,100,68,68,68,0 ; 110
db 0,0,56,68,68,68,56,0
db 0,0,120,68,120,64,64,0
db 0,0,56,72,56,8,4,0
db 0,0,44,48,32,32,32,0
db 0,0,60,64,56,4,120,0
db 0,16,56,16,16,16,8,0
db 0,0,68,68,68,72,52,0
db 0,0,68,68,40,40,16,0
db 0,0,68,68,84,84,40,0
db 0,0,68,40,16,40,68,0 ; 120
db 0,0,68,40,16,32,64,0
db 0,0,124,8,16,32,124,0
db 16,32,32,64,32,32,16,0
db 16,16,16,0,16,16,16,0
db 16,8,8,4,8,8,16,0
db 0,0,32,84,8,0,0,0
db 84,40,84,40,84,40,84,0 ; 127
endif
;
_data ends
page
_text segment
; setmode(mode);
;
; SETMODE --- change the display mode
; at entry: AL = 0 40x25 BW
; 1 40x25 COLOR
; 2 80x25 BW
; 3 80x25 COLOR
; 4 320x200 COLOR
; 5 320x200 BW
; 6 640x200 BW
; 7 80x25 BW (monochrome)
; 10h 640x350 COLOR (ega)
_setmode:
push bp
mov bp,sp
mov ax,[bp+4] ; get mode
cmp al,4 ; 320x200 CGA graphics?
jb smode ; jif no
;
; the following sets up the byte mask table for the bplotxy 'collision' function
; (currently is supported only by 320x200 CGA graphics mode 4).
;
push ax ; save mode
push es
push ds
pop es
cgamakemasks:
lea di,masks ; load offset of mask bytes
xor ah,ah ; there are four pixels per byte of
smloop: xor al,al ; CGA 320x200 color video RAM. Each
test ah,3 ; pixel has 2 bits, selecting one of
jz sml1 ; four colors. 00 = background color.
or al,3 ; these mask bytes are used during
sml1: test ah,0ch ; BPLOTXY to determine if a non-backgnd
jz sml2 ; color is being bplotted onto a
or al,0ch ; non-background color, resulting in a
sml2: test ah,30h ; 'collision'. There are 256 masks, 1
jz sml3 ; for each possible bplot byte. For
or al,30h ; each pixel (pair of bits), if either
sml3: test ah,0c0h ; bit is set, then both bits of the
jz sml4 ; mask are set, so by ANDing the masks
or al,0c0h ; with the bplot bytes and the video
sml4: stosb ; bytes, we can tell if any of the four
inc ah ; pixels in the current byte collide.
jnz smloop
pop es
pop ax
smode:
mov ah,0 ; bios int 10 function setmode
cmp al,10h ; EGA graphics?
jz isega ; jif yes
mov vidseg,0b800h ; default video ram segment to CGA
mov _machine,CGA ; default machine type to CGA
successful:
int 10h
mov ax,1
pop bp
ret
isega:
mov vidseg,0a000h ; set video ram segment to EGA
mov _machine,EGA ; set disptype to EGA
push ax
mov ah,12h ; return ega information
mov bx,0ff10h ; set bh = ff to see if it changes
int 10h ; if bh changes, it's ega
pop ax
cmp bh,0ffh ; ega?
jnz successful ; jif yes
xor ax,ax
pop bp
ret
page
;
; setcolors(colorset, color);
;
_setcolors:
push bp
mov bp,sp
mov bx,[bp+4] ; get colorset
mov ax,[bp+6] ; get color
call setcolor
pop bp
ret
;
setcolor:
cmp _machine,0
jnz egasetcolors
;
; cgasetcolors --- sets colorset, background color
;
; at entry: AL = background color (0-15)
; 0 black 6 brown 12 light red
; 1 blue 7 white 13 light magenta
; 2 green 8 gray 14 yellow
; 3 cyan 9 light blue 15 white bright
; 4 red 10 light green
; 5 magenta 11 light cyan
; BL = color set (1=cyan/magenta/white 0=green/red/brown)
cgasetcolors:
push ax ; save background color
mov bh,1 ; set color id 1 (select palette)
mov ah,11 ; set color palette function of int 10h
int 10h
pop bx ; recover background color
mov bh,0 ; set color id 0 (background color)
mov ah,11 ; set color palette function of int 10h
int 10h
ret
;
; sets ega palette registers
; on entry:
; AL = color value
; BL = palette number
;
egasetcolors:
mov bh,al ; copy color value
mov ah,10h ; set palette call
mov al,0 ; set palette color sub-function number
cmp bl,16 ; overscan?
jnz egasc ; jif no
inc al ; change sub-function
egasc:
int 10h
ret
page
;
; plotxy(x,y,color,rule);
;
_plotxy:
push bp
mov bp,sp
push si
push di
mov cx,[bp+4] ; get x
mov bx,[bp+6] ; get y
mov dx,[bp+8] ; get color
mov ax,[bp+10] ; get rule
mov dh,al
call pixel
pop di
pop si
pop bp
ret
;
; xxxPIXEL --- color a pixel on the display
;
; at entry: BX = y-coordinate
; CX = x-coordinate
; DL = color
; DH = replacement rule (0=force, 1=and, 2=or, 3=xor)
;
pixel:
cmp _machine,0
jnz egapixel
;
cgapixel:
call cgamapxy
push ds
mov ds,vidseg
or dh,dh ; force pixel?
jz pxyforce
cmp dh,3 ; xor pixel?
jz pxyxor
cmp dh,2 ; or pixel?
jz pxyor
pxyand:
or al,dl ; put and-mask into color byte
and [di],al ; and color into display
jmp short plotexit
pxyxor:
xor [di],dl ; xor color into display
plotexit:
pop ds
ret
pxyor:
or [di],dl ; or color into display
jmp plotexit
pxyforce:
and [di],al ; clear pixel in display
or [di],dl ; force new bits into display
jmp plotexit
;
egapixel:
call egamapxy
push es
mov es,vidseg
push dx ; save bit mask
shl cl,1
shl cl,1 ; set logical operation in ega controller
shl cl,1
mov dx,3ceh
mov al,3
out dx,al
inc dx
mov al,cl
out dx,al
dec dx
mov al,8
out dx,al ; set bit mask
inc dx
pop ax ; recover bit mask
out dx,al
mov dx,3c4h
mov al,2
out dx,al ; set plane mask (to set 1 bits of color)
inc dx
mov al,ch ; get color
out dx,al
mov ah,es:[di] ; latch current data first
mov byte ptr es:[di],0ffh ; blend in new bits
mov dx,3c4h
mov al,2
out dx,al ; set plane mask (to zero 0 bits of color)
inc dx
mov al,ch ; get color
not al ; invert
out dx,al
mov ah,es:[di] ; latch current data first
mov byte ptr es:[di],0 ; logic-force new off bits
pop es
ret
;
cgamapxy:
mov ax,199
sub ax,bx ; invert y coord
and ax,0fffeh ; trash lower bit for odd/even
shl ax,1
shl ax,1
shl ax,1
mov di,ax ; si = 16*y
shl ax,1
shl ax,1 ; ax = 64*y
add di,ax ; si = 16*y + 64*y = 80*y
test bl,1 ; odd or even scan line?
jnz cgamapodd
add di,2000h ; offset to odd bank
cgamapodd:
mov ax,cx ; get x-coord
shr ax,1
shr ax,1 ; ax = x/4 (cga320x200 = 4 pixels/byte)
add di,ax ; si = offset of byte containing pixel
and cl,3 ; keep bit address
shl cl,1
ror dl,1 ; get color info in msbits
ror dl,1
ror dl,cl ; put color info in right place for pixel
mov al,3fh ; get pixel mask
ror al,cl
ret
;
egamapxy:
mov ax,349
sub ax,bx ; invert y coord
shl ax,1
shl ax,1
shl ax,1
shl ax,1
mov di,ax ; di = 16*y
shl ax,1
shl ax,1 ; ax = 64*y
add di,ax ; di = 16*y + 64*y = 80*y
mov ax,cx ; get x-coord
shr ax,1
shr ax,1 ; ax = x/8 (ega650x350 = 8 pixels/byte)
shr ax,1
add di,ax ; di = offset of byte containing pixel
and cx,7 ; keep bit address
mov ch,dl ; save color
mov dl,80h
ror dl,cl ; put color info in right place for pixel
mov cl,dh ; save rule
ret
page
;
; bplotxy(x, y, height, width, picture, rule);
;
; BPLOTXY --- plot a raster picture
; at entry: BX = y-coordinate
; CX = x-coordinate
; DL = height (# of rows in picture)
; DH = width (# of bytes in picture)
; SI = ptr to picture
; BP = 0 for force, 8000h for xor
;
; at exit: AL = 0 if no collision, #0 if collision
_bplotxy:
push bp
mov bp,sp
cld
push si
push di
mov bx,[bp+6]
mov cx,[bp+4]
mov dx,[bp+8]
mov ax,[bp+10]
mov dh,al
mov si,[bp+12]
mov bp,[bp+14]
cmp _machine,0
jz cgabplot
jmp egabplot
cgabplot:
push dx ; save high,wide
call cgamapxy
pop dx ; recover
and bx,1
and bp,8000h
or bp,bx ; bp = even/odd row flag
lea bx,masks
mov maskbyte,0
push es
mov es,vidseg
bpxybeglin:
mov ch,dh ; copy bytes/row
xor ah,ah ; zero upper byte
bpxydoline:
mov al,[si] ; get first byte of data
shr ax,cl ; shift to correct bit alignment
push ax
xlat
and al,es:[di] ; check for collisions
or maskbyte,al
pop ax
test bp,8000h ; force?
jz bpxyf1 ; jif yes
xor es:[di],al ; xor in the byte
jmp short bpxyfcom
bpxyf1:
mov es:[di],al ; force it
bpxyfcom:
inc di ; move to next byte of display
lodsb ; refetch byte for upper this time
mov ah,al ; copy it
dec ch ; decrement bytes/row count
jnz bpxydoline ; jif til line is done
or cl,cl ; byte aligned?
jz bpxyaligned ; jif yes, we're done with row
xor al,al ; zero lower byte (last byte on row)
shr ax,cl ; shift to correct bit alignment
push ax
xlat
and al,es:[di] ; check for collisions
or maskbyte,al
pop ax
test bp,8000h ; force?
jz bpxyf2 ; jif yes
xor es:[di],al ; xor last bits into display
jmp short bpxyaligned
bpxyf2:
mov es:[di],al
bpxyaligned:
mov al,dh ; get bytes/row
xor ah,ah
sub di,ax ; move back to start of display box
xor bp,1 ; toggle odd/even flag
test bp,1 ; even next?
jnz bpxyeven ; jif yes
add di,2000h ; move to odd bank
jmp short bpxynext
bpxyeven:
sub di,1fb0h ; move back to even bank, next row
bpxynext:
dec dl ; decrement row counter
jnz bpxybeglin ; jif til done
pop es
mov al,maskbyte
pop di
pop si
pop bp
ret
;
;
egabplot:
push dx
call egamapxy
mov bl,dl ; save bit mask
pop dx ; recover high/wide
mov ah,dh ; copy width
mov bh,dl ; copy height
push es
mov es,vidseg
mov cl,0
test bp,8000h ; force?
jz egab2 ; jif yes
jmp segab2
egab2:
mov dx,3ceh
mov al,3
out dx,al ; set logical operation in ega controller
inc dx
mov al,cl
out dx,al
egab1:
mov cl,ah ; get width of picture
xor ch,ch
push di ; save screen pointer
push bx ; save bit mask
egab3:
mov dx,3ceh
mov al,8
out dx,al ; set bit mask
inc dx
mov al,bl
out dx,al
mov dx,3c4h
mov al,2
out dx,al ; set plane mask (to set 1 bits of color)
inc dx
mov al,[si] ; get next pixel color
out dx,al
mov al,es:[di] ; latch current data first
mov byte ptr es:[di],0ffh ; blend in new color bits
dec dx
mov al,2
out dx,al ; set plane mask (to zero 0 bits of color)
inc dx
lodsb ; get color
not al ; invert
out dx,al
mov al,es:[di] ; latch current data first
mov byte ptr es:[di],0 ; logic-force new off bits
ror bl,1
or bl,bl
jns egabok
inc di
egabok:
loop egab3
pop bx
pop di
add di,80 ; move to next row
dec bh
jnz egab1
mov ax,0
pop es
pop di
pop si
pop bp
ret
;
segab2:
mov cl,18h ; xor
mov dx,3ceh
mov al,3
out dx,al ; set logical operation in ega controller
inc dx
mov al,cl
out dx,al
segab1:
mov cl,ah ; get width of picture
xor ch,ch
push di ; save screen pointer
push bx ; save bit mask
segab3:
cmp byte ptr [si],0
jz egasnarf
mov dx,3ceh
mov al,8
out dx,al ; set bit mask
inc dx
mov al,bl
out dx,al
mov dx,3c4h
mov al,2
out dx,al ; set plane mask (to set 1 bits of color)
inc dx
mov al,[si] ; get next pixel color
out dx,al
mov al,es:[di] ; latch current data first
mov byte ptr es:[di],0ffh ; blend in new color bits
dec dx
mov al,2
out dx,al ; set plane mask (to zero 0 bits of color)
inc dx
mov al,[si] ; get color
not al ; invert
out dx,al
mov al,es:[di] ; latch current data first
mov byte ptr es:[di],0 ; logic-force new off bits
egasnarf:
inc si
ror bl,1
or bl,bl
jns segabok
inc di
segabok:
loop segab3
pop bx
pop di
add di,80 ; move to next row
dec bh
jnz segab1
mov ax,0
pop es
pop di
pop si
pop bp
ret
page
;
; line(x1, y1, x2, y2, color, rule);
;
_line:
push bp
mov bp,sp
mov word ptr stepx,1 ; init x step value
mov word ptr stepy,1 ; init y step value
mov bx,[bp+4] ; get x-coords of endpoints
mov x1,bx
mov ax,[bp+8]
mov x2,ax
sub ax,bx ; get difx
jnb gotdifx ; jif x2 >= x1
neg ax ; else get x1-x2
neg word ptr stepx ; make stepx = -1
gotdifx:
mov difx,ax ; save difx away
mov dx,[bp+6] ; get y-coords of endpoints
mov y1,dx
mov cx,[bp+10]
mov y2,cx
sub cx,dx ; get dify
jnb gotdify ; jif y2 >= y1
neg cx ; else get y1-y2
neg word ptr stepy ; make stepy = -1
gotdify:
mov dify,cx ; save dify away
mov ax,[bp+12] ; get color
mov color,al
mov al,[bp+14] ; get replacement rule
mov rule,al
;**************************************************************
; register usage:
;
; bp=incflag
; ds=data segment
; si=counter
; ax=scratch
; bx=row
; cx=scratch
; dx=row
;**************************************************************
;
xor bp,bp ; init flag
mov si,bp ; init counter
;
; if difx >= dify then stepx else stepy
;
mov ax,difx ; get difx
cmp ax,cx ; is difx >= dify ?
jb dostepy ; jif no
shr ax,1 ; get difx / 2
mov halfdifx,ax ; save away
mov bx,dx ; get y1
forcol:
mov cx,x1 ; get x1
jmp short forcolloop
fcl:
add cx,stepx
forcolloop:
call linedot
add si,dify ; add it to counter
cmp halfdifx,si ; if halfdifx >= counter
jnb notx ; then don't do it
or bp,bp ; if incflag
jnz notx ; then don't do it
inc bp ; set flag
add bx,stepy ; move to next row
notx:
cmp si,difx ; if counter < difx
jb colwhile ; then don't reset flag
sub si,difx ; dock counter by proper count
xor bp,bp ; reset flag
colwhile:
cmp cx,x2
jnz fcl
done:
pop bp
ret
;
;
dostepy:
mov ax,dify ; get dify
shr ax,1 ; get dify / 2
mov halfdify,ax ; save away
mov cx,bx ; get x1
forrow:
mov bx,y1 ; get y1
jmp short forrowloop
frl:
add bx,stepy
forrowloop:
call linedot
add si,difx ; add it to counter
cmp halfdify,si ; if halfdifx >= counter
jnb noty ; then don't do it
or bp,bp ; if incflag
jnz noty ; then don't do it
inc bp ; set flag
add cx,stepx ; move to next col
noty:
cmp si,dify ; if counter < dify
jb rowwhile ; then don't reset flag
sub si,dify ; dock counter by proper count
xor bp,bp ; reset flag
rowwhile:
cmp bx,y2
jnz frl
jmp done
;
;
;
; bx=row
; cx=col
; bp, si, bx, cx should not be destroyed
;
linedot:
push cx
push bx
push si
push bp
mov dl,color
mov dh,rule
call pixel
pop bp
pop si
pop bx
pop cx
ret
page
;
; horline(x1, y1, x2, color, rule);
;
_horline:
push bp
mov bp,sp
mov bx,[bp+4] ; get x1
mov x1,bx
mov cx,[bp+6] ; get y1
mov y1,cx
mov ax,[bp+8] ; get x2
mov x2,ax
mov dx,[bp+10] ; get color
mov color,dl
mov dx,[bp+12] ; get rule
mov rule,dl
sub ax,bx ; get difx
jnb hgotdifx ; jif x2 >= x1
neg ax ; else get x1-x2
mov dx,x2
mov x1,dx
mov x2,bx
hgotdifx:
inc ax ; # of dots to write
mov difx,ax ; save difx away
mov bx,cx ; get start y
mov cx,x1 ; get start x
mov dl,color
cmp _machine,0
jz cgahorline
jmp egahorline
cgahorline:
call cgamapxy
mov cx,difx
mov dh,rule
push ds
mov ds,vidseg
or dh,dh
jz hpxyforce
cmp dh,3
jz hpxyxor
cmp dh,2
jz hpxyor
hpxyand:
or dl,al ; force all other bits on for anding
hpxya:
and [di],dl ; and in color
ror dl,1
ror dl,1
ror al,1
ror al,1
or al,al
js hxandok
inc di
hxandok:
loop hpxya
jmp short hlexit
hpxyxor:
xor [di],dl ; xor color into display
ror dl,1
ror dl,1
ror al,1
ror al,1
or al,al
js hxorok
inc di
hxorok:
loop hpxyxor
hlexit:
pop ds
pop bp
ret
hpxyor:
or [di],dl ; or color into display
ror dl,1
ror dl,1
ror al,1
ror al,1
or al,al
js horok
inc di
horok:
loop hpxyor
jmp hlexit
hpxyforce:
and [di],al ; clear pixel in display
or [di],dl ; force new bits into display
ror dl,1
ror dl,1
ror al,1
ror al,1
or al,al
js hforceok
inc di
hforceok:
loop hpxyforce
jmp hlexit
;
;
egahorline:
call egamapxy
mov bl,dl ; save bit mask
mov bh,ch ; save color
mov cx,difx
mov ah,rule
push ds
mov ds,vidseg
shl ah,1
shl ah,1 ; set logical operation in ega controller
shl ah,1
mov dx,3ceh
mov al,3
out dx,al
inc dx
mov al,ah
out dx,al
egahl:
mov dx,3ceh
mov al,8
out dx,al ; set bit mask
inc dx
mov al,bl ; recover bit mask
test al,80h ; at start of byte?
jz eganot80 ; jif no
cmp cx,8 ; full byte to do?
jb eganot80 ; jif no
call egahlbytes ; do full bytes
or cx,cx ; any odd bits left?
jz egahlexit ; jif no
jmp egahl
eganot80:
out dx,al ; set bit mask
mov dx,3c4h
mov al,2
out dx,al ; set plane mask (to set 1 bits of color)
inc dx
mov al,bh ; get color
out dx,al
mov al,[di] ; latch current data first
mov byte ptr [di],0ffh ; blend in new color bits
dec dx
mov al,2
out dx,al ; set plane mask (to zero 0 bits of color)
inc dx
mov al,bh ; get color
not al ; invert
out dx,al
mov al,[di] ; latch current data first
mov byte ptr [di],0 ; logic-force new off bits
ror bl,1
or bl,bl
jns egahlok
inc di
egahlok:
loop egahl
egahlexit:
pop ds
pop bp
ret
;
egahlbytes:
mov al,0ffh ; write all bits of byte at once
out dx,al ; set bit mask
egahlb:
mov dx,3c4h
mov al,2
out dx,al ; set plane mask (to set 1 bits of color)
inc dx
mov al,bh ; get color
out dx,al
mov al,[di] ; latch current data first
mov byte ptr [di],0ffh ; blend in new color bits
dec dx
mov al,2
out dx,al ; set plane mask (to zero 0 bits of color)
inc dx
mov al,bh ; get color
not al ; invert
out dx,al
mov al,[di] ; latch current data first
mov byte ptr [di],0 ; logic-force new off bits
inc di
sub cx,8 ; decrement dot count by one bytes worth
cmp cx,8 ; another full byte left?
jnb egahlb ; jif yess
ret
page
;
; verline(x1, y1, y2, color, rule);
;
_verline:
push bp
mov bp,sp
push di
mov bx,[bp+4] ; get x1
mov x1,bx
mov cx,[bp+6] ; get y1
mov y1,cx
mov ax,[bp+8] ; get y2
mov y2,ax
mov dx,[bp+10] ; get color
mov color,dl
mov dx,[bp+12] ; get rule
mov rule,dl
sub ax,cx ; get difx
jnb vgotdify ; jif y2 >= y1
neg ax ; else get y1-y2
mov dx,y2
mov y1,dx
mov y2,cx
vgotdify:
inc ax ; # of dots to write
mov dify,ax ; save difx away
mov cx,bx
mov bx,y2
mov dl,color
cmp _machine,0
jz cgaverline
jmp egaverline
cgaverline:
call cgamapxy
mov cx,dify
mov dh,rule
push ds
mov ds,vidseg
or dh,dh
jz vpxyforce
cmp dh,3
jz vpxyxor
cmp dh,2
jz vpxyor
vpxyand:
or dl,al
test byte ptr es:y2,1 ; in upper 2000h bytes?
jz vaupper ; jif yes
vpand:
and [di],dl ; xor color into display
add di,2000h
dec cx
jz vpdone
vaupper:
and [di],dl
sub di,1fb0h
loop vpand
jmp short vpdone
vpxyxor:
test byte ptr es:y2,1 ; in upper 2000h bytes?
jz vupper ; jif yes
vpxor:
xor [di],dl ; xor color into display
add di,2000h
dec cx
jz vpdone
vupper:
xor [di],dl
sub di,1fb0h
loop vpxor
vpdone:
pop ds
pop di
pop bp
ret
vpxyor:
test byte ptr es:y2,1 ; in upper 2000h bytes?
jz voupper ; jif yes
vpor:
or [di],dl ; force new bits into display
add di,2000h
dec cx
jz vpdone
voupper:
or [di],dl
sub di,1fb0h
loop vpor
jmp vpdone
vpxyforce:
test byte ptr es:y2,1 ; in upper 2000h bytes?
jz vfupper ; jif yes
vpforce:
and [di],al ; clear pixel in display
or [di],dl ; force new bits into display
add di,2000h
dec cx
jz vpdone
vfupper:
and [di],al
or [di],dl
sub di,1fb0h
loop vpforce
jmp vpdone
;
;
egaverline:
call egamapxy
mov bl,dl ; save bit mask
mov bh,ch ; save color
mov cx,dify
mov ah,rule
push ds
mov ds,vidseg
shl ah,1
shl ah,1 ; set logical operation in ega controller
shl ah,1
mov dx,3ceh
mov al,3
out dx,al
inc dx
mov al,ah
out dx,al
mov dx,3ceh
mov al,8
out dx,al ; set bit mask
inc dx
mov al,bl ; recover bit mask
out dx,al
egavl:
mov dx,3c4h
mov al,2
out dx,al ; set plane mask (to set 1 bits of color)
inc dx
mov al,bh ; get color
out dx,al
mov al,[di] ; latch current data first
mov byte ptr [di],0ffh ; blend in new color bits
dec dx
mov al,2
out dx,al ; set plane mask (to zero 0 bits of color)
inc dx
mov al,bh ; get color
not al ; invert
out dx,al
mov al,[di] ; latch current data first
mov byte ptr [di],0 ; logic-force new off bits
add di,80 ; move to next line
loop egavl
pop ds
pop di
pop bp
ret
page
;
; clrscreen(color);
;
_clrscreen:
push bp
mov bp,sp
cld
push di
mov ax,[bp+4] ; get color
push es
mov es,vidseg
xor di,di
cmp _machine,0
jnz egaclear
cgaclear:
mov bx,ax
shl bx,1
shl bx,1
or ax,bx
shl bx,1
shl bx,1
or ax,bx ; build entire byte of color
shl bx,1
shl bx,1
or ax,bx
mov cx,8192
rep stosw
pop es
pop di
pop bp
ret
egaclear:
mov bl,al ; save color
mov dx,3ceh
mov al,3
out dx,al
inc dx
mov al,0 ; no rotate and no logical operation on data
out dx,al
mov dx,3ceh
mov al,8
out dx,al ; set bit mask
inc dx
mov al,0ffh ; all bits
out dx,al
mov dx,3c4h
mov al,2
out dx,al ; set plane mask (to set 1 bits of color)
inc dx
mov al,bl ; get color
out dx,al
push di
mov cx,28000 ; number of bytes on ega display
mov al,0ffh ; blend in new color bits
rep stosb
pop di
dec dx
mov al,2
out dx,al ; set plane mask (to zero 0 bits of color)
inc dx
mov al,bl ; get color
not al ; invert
out dx,al
mov al,0 ; logic-force new off bits
mov cx,28000
rep stosb
pop es
pop di
pop bp
ret
;
page
;
;
; setrand(seed);
;
; setrand - set random # seed
;
_setrand:
push bp
mov bp,sp
mov ax,[bp+4]
or ax,ax ; if seed specified
jnz setit ; use it
mov ah,2ch ; else
int 21h ; use system time (secs &
mov ax,dx ; 1/100's) to get rand seed
setit:
mov seed,ax ; save seed
mov word ptr [seed+2],0
pop bp
ret ; that's all folks
;
; rand();
;
; rand - fetch a new random number; at entry, cx=limit
; at exit, ax=random number
;
; formula: rand(i+1)=214013*rand(i)+2531011
;
_rand:
push bp
mov bp,sp
push di
mov di,[seed+2]
or di,di ; zero?
mov ax,3
mov bx,43fdh
mov cx,[seed]
jz zerodi
mul cx
mov di,ax
mov ax,bx
mul word ptr [seed+2]
add di,ax
zerodi:
mov ax,bx
mul cx
add dx,di
add ax,9ec3h
adc dx,26h
mov [seed],ax
mov [seed+2],dx
mov ax,dx
xor dx,dx
mov cx,[bp+4]
div cx
mov ax,dx
pop di
pop bp
ret
;
page
_beepoff:
in al,61h
and al,0fch
out 61h,al
ret
;
; BEEPON --- turns beeper on with timer 2 gate to value in AX at entry.
;
_beepon:
cmp _beepflg,0
jz boret
push bp
mov bp,sp
mov al,0b6h
out 43h,al
mov ax,[bp+4]
out 42h,al
mov al,ah
out 42h,al
in al,61h
or al,3
out 61h,al
pop bp
boret:
ret
;
page
;
;
; flabel (x, y, string, fore_color, back_color, rule);
;
_flabel:
push bp
mov bp,sp
cld
push si
push di
push es
mov cx,[bp+4]
mov dx,[bp+6]
mov si,[bp+8]
mov ax,[bp+10]
mov color,al
mov ax,[bp+12]
mov backclr,al
mov ax,[bp+14]
mov rule,al
mov x1,cx
mov y1,dx
mov string,si
floop:
mov si,string ; get ptr to string
lodsb ; get next char
mov string,si ; save new ptr
cmp al,0 ; done?
jz fldone ; jif yes
call fchar ; label the char
add x1,6 ; move to next char space
jmp floop ; do next
;
fldone:
pop es
pop di
pop si
pop bp
ret
;
; cx = x1
; dx = y1
; si = char byte ptr
; al = char byte
;
fchar:
lea si,chartab ; address of char data
cbw
shl ax,1
shl ax,1
shl ax,1
add si,ax ; point to actual char data
mov cx,x1 ; get top left x address
mov dx,y1 ; get top left y address
mov byte ptr rowcnt,8 ; # of rows of char data
bytloop:
lodsb ; get next byte (row)
mov byte ptr colcnt,6 ; # of cols per row
shl ax,1 ; throw away leading blanks
if font1
shl ax,1
shl ax,1
endif
push si ; save char data ptr
bitloop:
mov ah,backclr ; default background color
shl al,1 ; get the next bit
jnc flbc ; jif bit clear, use background color
mov ah,color ; else load foreground color
flbc:
push ax ; save rest of byte
push bx
push cx
push dx
mov bx,dx ; move y-coord
mov dl,ah ; move color
mov dh,rule ; get rule
call pixel ; plot it
pop dx
pop cx
pop bx
pop ax
inc cx ; move to right one dot
dec byte ptr colcnt ; done with byte?
jnz bitloop ; jif no
pop si ; recover char data ptr
sub cx,6 ; move back to left of space
dec dx ; move down a row
dec byte ptr rowcnt ; done with char?
jnz bytloop ; jif no
ret
;
_iskey:
mov ah,1
int 16h
jnz iskeyret
mov ax,0
iskeyret:
ret
;
_key:
mov ah,0
int 16h
ret
page
;
; movebytes(*to, *from, count);
;
_movebytes:
push bp
mov bp,sp
push si
push di
mov di,[bp+4] ; get destination
mov si,[bp+6] ; get source
mov cx,[bp+8] ; get count
or cx,cx ; any to move?
jz mbdone ; jif no
cmp di,si ; to < from?
ja movrev ; jif no, negative move
cld
movcom:
rep movsb
mbdone:
cld
pop di
pop si
pop bp
ret
;
movrev:
add si,cx ; move to other end
add di,cx
dec si
dec di
std
jmp movcom
;
;
;
; newbplotxy(x, y, height, width, picture, rule);
;
; BPLOTXY --- plot a raster picture
; at entry: BX = y-coordinate
; CX = x-coordinate
; DL = height (# of rows in picture)
; DH = width (# of bytes in picture)
; SI = ptr to picture
; BP = 0 for force, 3 for xor
;
_newbplotxy:
cmp _machine,0
jnz newegabplot
newegabplot:
push bp
mov bp,sp
cld
push si
push di
mov bx,[bp+6] ; get y
mov cx,[bp+4] ; get x
mov dx,[bp+8] ; get height
mov ax,[bp+10] ; get width
mov widtht,ax
mov height,dx
mov si,[bp+12] ; get ptr to Images
mov ax,[bp+14] ; get rule
call egamapxy
mov cx,[bp+4] ; init shift count
neg cx
and cl,7
mov ax,0ffh ; init left/right masks
shl ax,cl
mov ch,ah ; lf bit mask
mov bh,al ; rt bit mask
push es
mov es,vidseg
mov ah,0
cmp word ptr [bp+14],0 ; force?
jz newegab2 ; jif yes
mov ah,18h
newegab2:
mov dx,3ceh
mov al,3
out dx,al ; set logical operation in ega controller
inc dx
mov al,ah
out dx,al
mov byte ptr pcount,1 ; init plane counter
or cl,cl ; byte aligned? (no shifts needed?)
jnz newega0 ; jif no
jmp newegabyte
newega0:
push di ; save start of image screen ptr
mov dx,3c4h ; enable current plane
mov al,2
out dx,al
inc dx
mov al,pcount
out dx,al
mov ax,height
mov hcount,ax ; init height counter
newega1:
push di ; save start of line screen ptr
mov ax,widtht
mov wcount,ax ; init width counter
mov dx,3ceh ; set lfbmask
mov al,8
out dx,al
inc dx
mov al,ch
out dx,al
xor ah,ah ; init upper bits to zeros
lodsb ; get first byte of image line
shl ax,cl ; rotate it
xchg al,ah ; get ms bits
mov bl,es:[di] ; latch current screen data into ega controller
stosb ; write new data according to rule
dec wcount ; last byte?
jz newega2 ; jif yes
mov dx,3ceh ; set bit mask to all bits
mov al,8
out dx,al
inc dx
mov al,0ffh
out dx,al
newega3:
lodsb ; get next byte of image data
shr ah,cl ; get leftover bits back in position
shl ax,cl ; mix bits with leftovers
xchg al,ah ; get ms bits
mov bl,es:[di] ; latch previous data
stosb ; update with new data
dec wcount ; last byte?
jnz newega3 ; jif no
newega2:
mov dx,3ceh ; set bit mask to right side
mov al,8
out dx,al
inc dx
mov al,bh
out dx,al
mov al,ah
mov bl,es:[di] ; latch current data
stosb ; update with new
pop di ; move back to start of screen line
add di,80 ; move to next line
dec hcount ; last line?
jnz newega1 ; jif no, do next line
pop di ; move back to start of screen image
shl pcount,1 ; move to next plane
test pcount,16 ; done?
jz newega0 ; jif no
mov ax,0 ; return 0
pop es
pop di
pop si
pop bp
ret
;
newegabyte:
mov dx,3ceh ; set bit mask
mov al,8
out dx,al
inc dx
mov al,0ffh
out dx,al
newega10:
push di ; save start of image screen ptr
mov dx,3c4h ; enable current plane
mov al,2
out dx,al
inc dx
mov al,pcount
out dx,al
mov ax,height
mov hcount,ax ; init height counter
newega11:
push di ; save start of line screen ptr
mov ax,widtht
mov wcount,ax ; init width counter
newega12:
mov al,es:[di] ; latch current screen data into ega controller
movsb ; copy new data according to rule
dec wcount ; last byte?
jnz newega12 ; jif no
pop di ; move back to start of screen line
add di,80 ; move to next line
dec hcount ; last line?
jnz newega11 ; jif no, do next line
pop di ; move back to start of screen image
shl pcount,1 ; move to next plane
test pcount,16 ; done?
jz newega10 ; jif no
mov ax,0 ; return 0
pop es
pop di
pop si
pop bp
ret
;
; take_timer();
;
old1coff dw ?
old1cseg dw ?
;
_take_timer:
push bp
mov bp,sp
push si
push di
mov ax,351ch ; get old timer interrupt vector
push es
int 21h
mov cs:[old1cseg],es
mov cs:[old1coff],bx ; save it
pop es
push ds
push cs
pop ds
lea dx,timerint
mov ax,251ch ; take it
int 21h
pop ds
pop di
pop si
pop bp
ret
;
; give_timer();
;
_give_timer:
push bp
mov bp,sp
push si
push di
push ds
mov ds,cs:[old1cseg]
mov dx,cs:[old1coff]
mov ax,251ch ; give it
int 21h
pop ds
pop di
pop si
pop bp
ret
;
; beep_seq(listptr);
;
_beep_seq:
cmp _beepflg,0
jz bsret
push bp
mov bp,sp
mov ax,[bp+4]
mov beepptr,ax
call beepsub
pop bp
bsret:
ret
;
; timer interrupt
;
timerint:
push es
push ds
push ax
push bx
push cx
push dx
push si
push di
push bp
mov ax,dgroup
mov ds,ax
inc _timepass
mov ax,beeptime
or ax,ax
jz texit
dec beeptime
jnz texit
call beepsub
texit:
pop bp
pop di
pop si
pop dx
pop cx
pop bx
pop ax
pop ds
pop es
jmp dword ptr cs:old1coff
;
beepsub:
mov si,beepptr
cld
lodsw ; get next frequency
or ax,ax ; end of list?
jnz freqok ; jif no
in al,61h ; else turn beeper off
and al,0fch
out 61h,al
ret
freqok:
push ax
mov al,0b6h
out 43h,al
pop ax
out 42h,al ; write it to timer 2
mov al,ah
out 42h,al
in al,61h
or al,3
out 61h,al
lodsw ; get next duration
mov beeptime,ax
mov beepptr,si
ret
;
_text ends
;
end